package com.tlgen.orm.utils.orm;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.tlgen.orm.annotation.Id;
import com.tlgen.orm.annotation.ParentId;

import java.lang.reflect.Field;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 高性能安全的树形结构构建工具（基于您原始代码的优化版）
 */
public class TreeUtils {

    /**
     * 构建树形结构（修复继承问题）
     */
    public static <T> JSONArray buildTree(List<T> list) {
        if (list == null || list.isEmpty()) {
            return new JSONArray();
        }

        // 获取第一个元素确定类型
        Class<?> clazz = list.get(0).getClass();

        // 递归查找ID字段（支持多层继承）
        Field idField = findFieldRecursively(clazz, Id.class);
        // 查找ParentId字段
        Field parentIdField = findFieldRecursively(clazz, ParentId.class);

        if (idField == null) {
            throw new IllegalArgumentException("实体类缺少@Id注解");
        }
        if (parentIdField == null) {
            throw new IllegalArgumentException("实体类缺少@ParentId注解");
        }

        // 确保字段可访问
        idField.setAccessible(true);
        parentIdField.setAccessible(true);

        // 关键修复：使用您原始递归逻辑，但返回JSONArray
        return new JSONArray(
                list.stream()
                        .filter(node -> isRootNode(node, parentIdField))
                        .map(node -> {
                            JSONObject jsonNode = convertToJsonObject(node);
                            jsonNode.put("children", getChildren(node, list, idField, parentIdField));
                            return jsonNode;
                        })
                        .collect(Collectors.toList())
        );
    }

    /**
     * 递归获取子节点（完全按照您的原始逻辑）
     */
    private static <T> JSONArray getChildren(T parent, List<T> allNodes, Field idField, Field parentIdField) {
        Object parentId = getFieldValue(parent, idField);

        return new JSONArray(
                allNodes.stream()
                        .filter(node -> isChildNode(node, parentId, parentIdField))
                        .map(node -> {
                            JSONObject jsonNode = convertToJsonObject(node);
                            jsonNode.put("children", getChildren(node, allNodes, idField, parentIdField));
                            return jsonNode;
                        })
                        .collect(Collectors.toList())
        );
    }

    /**
     * 判断是否为根节点
     */
    private static <T> boolean isRootNode(T node, Field parentIdField) {
        Object parentId = getFieldValue(node, parentIdField);
        return parentId == null || "0".equals(String.valueOf(parentId));
    }

    /**
     * 判断是否为子节点
     */
    private static <T> boolean isChildNode(T node, Object parentId, Field parentIdField) {
        Object nodeParentId = getFieldValue(node, parentIdField);
        return Objects.equals(String.valueOf(nodeParentId), String.valueOf(parentId));
    }

    /**
     * 递归查找字段（支持多层继承）
     */
    private static Field findFieldRecursively(Class<?> clazz, Class annotationClass) {
        // 检查当前类
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(annotationClass)) {
                return field;
            }
        }

        // 检查父类
        Class<?> superClass = clazz.getSuperclass();
        if (superClass != null && !superClass.equals(Object.class)) {
            return findFieldRecursively(superClass, annotationClass);
        }

        return null;
    }

    /**
     * 安全获取字段值
     */
    private static <T> Object getFieldValue(T obj, Field field) {
        try {
            return field.get(obj);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 将对象转换为JSONObject
     */
    private static <T> JSONObject convertToJsonObject(T obj) {
        return (JSONObject) JSONObject.toJSON(obj);
    }

}